#include<iostream>
#include<unistd.h>
#include<pthread.h>
#include<cstring>
#include<unistd.h>
#include<thread>

#define MUN 10

class pthread
{
public:
    pthread()
    {

    }
    void goz(std::string name,int a,int b)
    {
        _name = name;
        _a = a;
        _b = b;
    }
    std::string name()
    {
        return _name;
    }
    int jg()
    {
        return _a + _b;
    }
    int A()
    {
        return _a;
    }
    int B()
    {
        return _b;
    }
    void ID(pthread_t id)
    {
        _id = id;
    }
    pthread_t RID()
    {
        return _id;
    }
private:
    std::string _name;
    int _a;
    int _b;
    pthread_t _id;
};

void* run1(void* args)
{

    std::string name = static_cast<const char*>(args);
    while(true)
    {
        //std::cout <<"name:"<< name   <<"新线程id:"<< zhh(pthread_self()) << std::endl;
        sleep(1);
        break;
    }
    return (void*)90;
}
//转16进制
std::string zhh(pthread_t tid)
{
    //4.进程内的函数，线程共享
     char buff[64];
     snprintf(buff,sizeof(buff),"0x%lx",tid);
     return buff;
}

int main()
{
    pthread td[MUN];
    for(int i=0;i<MUN;i++)
    {
        char buff[64];
        snprintf(buff,sizeof(buff),"run-%d",i);
        td[i].goz(buff,i*10,i*20);
    }
    //创建10个线程
    for(int i=0;i<MUN;i++)
    {
        pthread_t id;
        pthread_create(&id,nullptr,run1,&td[i]);
        td[i].ID(id);
    }
    //等待线程
    for(int i=0;i<MUN;i++)
    {
        pthread_join(td[i].RID(),nullptr);
    }
    //打印结果
    for(int i=0;i<MUN;i++)
    {
        //printf("td[%d]: %d+%d=%d,id:[%ld]\n",i,td[i].A(),td[i].B(),td[i].jg(),zhh(td[i].RID()));
        std::cout << td[i].A()<<"+"<<td[i].B()<<"="<<td[i].jg()<<"[id]:"<< zhh(td[i].RID()) << std::endl;
    }

    return 0;
}






// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid,nullptr,run1,(void*)"run-1");
//     std::cout << "主线程等待，"<<"主线程id:"<< zhh(pthread_self())<<"tid:" << zhh(tid) << std::endl;
//     void* ret = nullptr;
//     pthread_join(tid,&ret);
//     std::cout << "数值:" << (long long int)ret <<std::endl;

    

//     return 0;
// }















//int* arr = nullptr;


// void* run2(void* args)
// {
//     std::string name = static_cast<const char*>(args);
//     while(true)
//     {
//         if(arr != nullptr)
//         {
//             std::cout << name << "修改a:" << (*arr)++  << std::endl;
//         }
//         sleep(1);
//     }
// }

// void* run1(void* args)
// {
//     //给自己分离
//     //pthread_detach(pthread_self());
//     std::string name = static_cast<const char*>(args);
//     while(true)
//     {
//         //std::cout << name << "a:" << a  << std::endl;
//         std::cout << "新线程" << std::endl;
//         sleep(1);
//     }
// }

// int main()
// {
//     pthread_t tid1;
//     pthread_create(&tid1,nullptr,run1,(void*)"run-1");
//     //给指定线程分离
//     pthread_detach(tid1);
//     sleep(2);
//     int n = pthread_join(tid1,nullptr);
//     std::cout << "主线程等待，n:" << n << std::endl;
//     // pthread_create(&tid2,nullptr,run2,(void*)"run-2");

 
//     // pthread_join(tid2,nullptr);
//     return 0;
// }






//int gmun = 100;

// //转16进制
// std::string zhh(pthread_t tid)
// {
//     //4.进程内的函数，线程共享
//      char buff[64];
//      snprintf(buff,sizeof(buff),"0x%lx",tid);
//      return buff;
// }

// // void* run2(void* args)
// // {
// //     std::string name = static_cast<const char*>(args);
// //     while(true)
// //     {
// //         std::cout << "我是新线程,名称是:" << name <<"新线程的tid:"<< zhh(pthread_self()) << "全局变量(检测):" << gmun << std::endl;
// //         //全局变量++
// //         gmun++;
// //         sleep(1);
// //         int* p= nullptr;
// //         *p = 100;
// //     }
// //     return 0;
// // }

// class thrdata
// {
// public:
//     thrdata() {
//     }

//     void init(const std::string& name, int a, int b) 
//     {
//         _name = name;
//         _a = a;
//         _b = b;
//     }


//     void jia() 
//     {
//         _return = _a + _b;
//     }
//     int Return()
//     {
//         return _return;
//     }
//     void setid(pthread_t tid)
//     {
//         _tid = tid;
//     }
//     pthread_t id()
//     {
//         return _tid;
//     }

//     std::string Name() {
//         return _name;
//     }
//     int x(){ return _a; }
//     int y(){ return _b; }

//     ~thrdata() {
//     }


// private:
//     std::string _name;
//     int _a;
//     int _b;
//     int _return;
//     pthread_t _tid;
// };


// void* run(void* args)
// {
//     //std::string name = static_cast<const char*>(args);
//     thrdata *td = static_cast<thrdata *>(args);

//     while(true)
//     {
        
//         std::cout << "我是新线程,名称是:" << td->Name() <<"新线程的tid:"<< zhh(pthread_self()) << "全局变量(修改):" << gmun << std::endl;

//         //std::cout << "结果:" << td->jia() << std::endl;
//         td->jia();

//         //全局变量++
//         gmun++;
//         sleep(5);
//         //5秒后退出
//         break;
//     }

//     return td;

//     // //理论上，堆空间也是共享的！谁拿着堆空间的入口地址，谁就能访问该堆区！
//     // int* p = new int(20);
//     // return (void*)p;
//     //return (void*)10;//线程退出方式1，线程入口函数return ,表示线程退出
// }

// #define MUN 10

// int main()
// {
//     thrdata td[MUN];//数组
//     //准备我们要加工处理的数据
//     for(int i=0;i < MUN;i++)
//     {
//         char cid[64];
//         //将值写到cid
//         snprintf(cid,sizeof(cid),"thread-%d",i);
//         //交给1~10个类thrdata
//         td[i].init(cid,i*10,i*20);
//     }
//     //创建多线程-10个线程
//     for(int i=0;i<MUN;i++)
//     {
//         pthread_t id;
//         pthread_create(&id,nullptr,run,&td[i]);
//         //id给类thrdata
//         td[i].setid(id);
//     }
//     //等待回收多个线程
//     for(int i=0;i < MUN;i++)
//     {
//         pthread_join(td[i].id(),nullptr);
//     }

//     //汇总处理结果
//     for(int i=0;i<MUN;i++)
//     {
//         printf("td[%d]: %d+%d=%d[%ld]\n",i,td[i].x(),td[i].y(),td[i].Return(),td[i].id());
//     }

//     // pthread_t tid1;
//     // thrdata *td = new thrdata("run-1",10,20);
//     // pthread_create(&tid1,nullptr,run,td);

//     // thrdata* ret = nullptr;
//     // //阻塞等待新线程
//     // int n = pthread_join(tid1,(void**)&ret);
//     // if(n != 0)//不等于0错误
//     // {
//     //     std::cerr << "error:" <<n << " , " << strerror(n) << std::endl;
//     // }
//     // std::cout << "回收新线程成功,返回值" << ret->Return() << std::endl;

//     // delete ret;
//     //std::cout << "回收新线程成功,返回值" << (long long int)ret << std::endl;
//     //std::cout << "回收新线程成功,返回值" << *(int*)ret << std::endl;
    
//     // pthread_t tid2;
//     // pthread_create(&tid2,nullptr,run2,(void*)"run-2");

//     // // pthread_t tid3;
//     // // pthread_create(&tid3,nullptr,run,(void*)"run-3");

//     // // pthread_t tid4;
//     // // pthread_create(&tid4,nullptr,run,(void*)"run-4");
      
//     // //std::cout << "线程tid:" << tid << std::endl;
//     // printf("线程tid: 0x%lx\n",tid1);
//     // while(true)
//     // {
//     //     std::cout << "我是main线程" << std::endl;
//     //     sleep(1);
//     // }
//     // return 0;
// }














// void* run(void* args)
// {
//     std::string name = static_cast<const char*>(args);//名称转换成字符串类型
//     while(true)
//     {
//         std::cout << "我是新线程，我的名称是：" <<name << std::endl;
//         sleep(1);
//     }
//     return 0;
// }

// int main()
// {
//     pthread_t tid;
//     int n = pthread_create(&tid,nullptr,run,(void*)"run-1");
//     if(n != 0)//不等于0，错误打印错误码
//     {
//         std::cout << "error:" << strerror(n) << std::endl;
//         return 1;
//     }

//     while(true)
//     {
//         std::cout << "我是main线程...." << std::endl;
//         sleep(1);
//     }
//     return 0;
// }



// std::thread t([](){
//     while(true)
//     {
//         std::cout << "我是新线程"  << std::endl;
//         sleep(1);
//     }
// });

// while(true)
// {
//     std::cout << "我是主线程"  << std::endl;
//     sleep(1);
// }







// //新线程
// void* run(void* args)
// {
//     while(true)
//     {
//         std::cout << "新线程 , pid:"<< getpid() << std::endl;
//         sleep(1);
//     }
//     return nullptr;
// }

// int main()
// {
//     std::cout << "我是一个进程我的pid：" << getpid() << std::endl;
    
//     pthread_t tid;//线程id
//     //创建线程
//     pthread_create(&tid,nullptr,run,(void*)"thr-1");//线程名称是thr-1，

//     //主线程
//     while(true)
//     {
//         std::cout << "主线程,pid:" << getpid() << std::endl;
//         sleep(1);
//     }
//     return 0;
// }
